home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / cool / ge_cool.lha / GE_COOL2.1 / cpp / cpp7.c < prev    next >
C/C++ Source or Header  |  1992-04-13  |  28KB  |  1,003 lines
  1. /*
  2.  
  3.  
  4.  Copyright (C) 1990 Texas Instruments Incorporated.
  5.  
  6.  Permission is granted to any individual or institution to use, copy, modify,
  7.  and distribute this software, provided that this complete copyright and
  8.  permission notice is maintained, intact, in all copies and supporting
  9.  documentation.
  10.  
  11.  Texas Instruments Incorporated provides this software "as is" without
  12.  express or implied warranty.
  13.  
  14.  
  15.  *
  16.  *                C P P 7 . C
  17.  *
  18.  *               Process Internal/External defmacros
  19.  *
  20.  * Edit history
  21.  * 15-Mar-89    LGO    Initial design and implementation.
  22.  * 20-Oct-89    AFM     OS2, XENIX and AIX port.
  23.  * 19-Jan-90    DKM     MVS support
  24.  * 01-Sep-90    MJF     External macros support for OS/2 by using temp file
  25.  * 25-Jun-91    GPD    Remove #elif to make more portable.
  26.  *            Added support for Interactive Unix.
  27.  */
  28.  
  29. #include    <stdio.h>
  30. #include    <ctype.h>
  31. #include    "cppdef.h"
  32.  
  33. #if defined(vms)
  34. #include        <types.h>
  35. #else
  36. #if !defined(SYS_OSVS)
  37. #include        <sys/types.h>
  38. #endif
  39. #endif
  40.  
  41. #if defined(_AIX)
  42. #include        <sys/select.h>
  43. #endif
  44.  
  45. #include    "cpp.h"
  46.  
  47. #if defined(M_XENIX)
  48. #include        <string.h>
  49. #include        <sys/fcntl.h>
  50. #include        <sys/file.h>
  51. #else
  52. #if defined(DOS) || defined(MSDOS)
  53. #include        <string.h>
  54. #include        <fcntl.h>
  55. #else
  56. #if defined(SYS_OSVS)
  57. #include        <string.h>
  58. #include        <fcntl.h>
  59. #else
  60. #if defined(vms)
  61. #include        <file.h>
  62. #else
  63. #if defined(M_INTERACTIVE)
  64. #include    <unistd.h>
  65. #include    <sys/bsdtypes.h>
  66. #include    <sys/fcntl.h>
  67. #endif
  68. #include        <sys/file.h>
  69. #endif
  70. #endif
  71. #endif
  72. #endif
  73.  
  74. #if HOST == SYS_VMS
  75. #define F_OK            0      /* does file exist */
  76. #define X_OK            1      /* is file executable */
  77. #define W_OK            2      /* is file writable */
  78. #define R_OK            4      /* is file readable */
  79. #endif
  80.  
  81. int current_line;            /* line at start of defmacro global */
  82. char current_file[256];            /* file at start of defmacro global */
  83.  
  84. FILEINFO *MacInFile, *MacOutFile;
  85. char* MacOutEnd;
  86.  
  87. struct macroargs {
  88.   char* name;
  89.   char  expanding;        /* Non-zero when args are macro expanded */
  90.   char  recursive;        /* Non-zero when recursive */
  91.   char  delimiter;        /* Delimiter */
  92.   char  conditional;        /* Expand only if this char found after name */
  93.   internal_expander expander;    /* Macro expander or NULL if file */
  94.   char *program;        /* macro program pathname */
  95.   char *args[1];        /* arg list (vector of strings) */
  96. };
  97.  
  98. extern FILEINFO* getfile();
  99.  
  100. /* Getfile without side effects */
  101. FILEINFO*
  102. get_temp_file (bufsize, name)
  103.      int bufsize;
  104.      char* name;
  105. {
  106.   FILEINFO* file = getfile(bufsize, name);
  107.   infile = file->parent;
  108.   file->parent = NULL;
  109.   line = infile->line;
  110.   return(file);
  111. }
  112.  
  113. static FILEINFO*
  114. next_buffer(Buffer)
  115.    FILEINFO* Buffer;
  116. {
  117.   FILEINFO* new = get_temp_file(NBUFF, Buffer->filename);
  118.   new->parent = Buffer->parent;    /* When new ends read from infile */
  119.   Buffer->parent = new;            /* When Buffer dries up, read from new */
  120.   *Buffer->bptr = EOS;
  121.   Buffer->bptr = Buffer->buffer;
  122.   return new;
  123. }
  124.  
  125. /* Helper function for the getchar macro used by internal defmacros */
  126. char
  127. NextMacInChar() {
  128.   char c;
  129.   do {
  130.     if (MacInFile->parent == NULL) {
  131.       return(EOF);              /* End of file */
  132.     } else {
  133.       FILEINFO* new = MacInFile->parent;
  134.       free(MacInFile->filename);      /* Free name and    */
  135.       if (MacInFile->progname != NULL)      /* if a #line was seen, */
  136.     free(MacInFile->progname);      /* free it, too.    */
  137.       free(MacInFile->buffer);          /* Free buffer */
  138.       free((char *) MacInFile);          /* Free file space    */
  139.  
  140.       *new->bptr = EOS;
  141.       new->bptr = new->buffer;
  142.       c = *new->bptr++;
  143.       MacInFile = new;
  144.     }
  145.   }
  146.   while (c == EOS);
  147.   return (c);
  148. }
  149.  
  150. void
  151. NextMacOutBuffer()
  152. {
  153.   MacOutFile = next_buffer(MacOutFile);
  154.   MacOutEnd = MacOutFile->buffer + (NBUFF - 1);
  155. }
  156.  
  157. void
  158. NextMacOutString(s)
  159. char* s;
  160. { 
  161.   int slen = strlen(s);
  162.   int blen;
  163.   while ((blen = (MacOutEnd - MacOutFile->bptr) - 1) < slen) {
  164.     if(blen>0) {
  165.       strncpy(MacOutFile->bptr, s, blen);
  166.       MacOutFile->bptr += blen;
  167.       s += blen;
  168.       slen -= blen;
  169.     }
  170.     NextMacOutBuffer();
  171.   }
  172.   strcpy(MacOutFile->bptr, s);
  173.   MacOutFile->bptr += slen;
  174. }
  175.  
  176. static char* new_buffer (obuf, obufend, file)
  177.      char*      obuf;            /* Output Buffer */
  178.      char**     obufend;        /* End of Output Buffer */
  179.      FILEINFO    **file;            /* Funny #include    */
  180. {
  181.   FILEINFO* old = *file;
  182.   FILEINFO* new = get_temp_file(NBUFF, old->filename);
  183.   *obuf = EOS;
  184.   /* NOTE: this code leaves file->bptr pointing at the END of the */
  185.   /*       buffer.  This is to keep double_copy from having to use */
  186.   /*       strlen to get the number of bytes in the buffer */
  187.   old->bptr = obuf;
  188.   old->parent = new;          /* When file dries up, read from new */
  189.   *obufend = new->buffer + (NBUFF - 1);
  190.   *file = new;
  191.   return new->bptr;
  192. }
  193. /*
  194.  * Copy from the input stream to a buffer, stopping at the first
  195.  * delim, but including everything with matching {} [] ()
  196.  * <> "" '' and comments found along the way.
  197.  */
  198. static FILEINFO*
  199. copy_body(file, delim, is_string, is_top_level, expand)
  200.      FILEINFO    *file;            /* Funny #include    */
  201.      char delim;            /* Char to stop on */
  202.      int is_string;            /* True when inside a string */
  203.      int is_top_level;            /* True when the outer most call */
  204.      int expand;            /* if non-zero, macroexpand */
  205. {
  206.   register char* obuf;            /* Current output pointer */
  207.   register char c;            /* Current character */
  208.   char p;                /* Previous character */
  209.   char* obufend;            /* End of output buffer */
  210.   char newdelim;            /* New delimiter to look for */
  211.   int new_is_string = FALSE;        /* New is_string flag */
  212.  
  213.   obuf = file->bptr;            /* -> output buffer    */
  214.   obufend = file->buffer + (NBUFF - 1);    /* Note its end        */
  215.  
  216.   *obuf = EOS;
  217.   for (p = EOS; (c = get()) != EOF_CHAR; p = c) {
  218.     if (obuf >= obufend)        /* End of buffer, get a new one */
  219.       obuf = new_buffer(obuf, &obufend, &file);
  220.     if(expand && !is_string && type[c] == LET) {    /* expand macros */
  221.       c = macroid(c);            /* Grab the token    */
  222.       if (obuf >= obufend-strlen(tokenbuf)) /* End of buffer, get a new one */
  223.     obuf = new_buffer(obuf, &obufend, &file);
  224.       if(type[c] == LET) {
  225.     strcpy(obuf, tokenbuf);
  226.     obuf += strlen(tokenbuf);
  227.     continue;
  228.       }
  229.     }
  230.     *obuf++ = c;
  231.     if (c == delim)            /* Quit when delimeter found */
  232.       if (delim != '/' || p == '*') {    /* Special test for end of comment */
  233.     *obuf = EOS;
  234.     file->bptr = obuf;
  235.     return(file);
  236.       }
  237.     if (!is_string) {
  238.       switch (c) {           /* Look for new delimeters when not is_string */
  239.       case DEF_MAGIC:
  240.       case TOK_SEP:
  241.       case COM_SEP:
  242.     obuf--; continue;          /* Ignore magic characters */
  243.       case '{':  newdelim = '}'; break;
  244.       case '[':  newdelim = ']'; break;
  245.       case '(':  newdelim = ')'; break;
  246.       case '<':
  247.     if (delim != '>') continue;
  248.     newdelim = '>'; break;
  249.       case '\'':  newdelim = '\''; new_is_string = TRUE; break;
  250.       case '\"':  newdelim = '\"'; new_is_string = TRUE; break;
  251.       case '*':                  /* Start of C comment? */
  252.     if (p == '/') {
  253.       if (keepcomments) {
  254.         newdelim = '/';
  255.         new_is_string = TRUE;
  256.         break;
  257.       }                  /* Eat comment */
  258.       for (; (c = get()) != EOF_CHAR; p = c) {
  259.         if (c == '\n') {
  260.           if (obuf >= obufend)      /* End of buffer, get a new one */
  261.         obuf = new_buffer(obuf, &obufend, &file);
  262.           *obuf++ = c;          /* Preserve newlines */
  263.         } else if (c == '/' && p == '*') break;
  264.       }
  265.       if (obuf+2 >= obufend)      /* End of buffer, get a new one */
  266.         obuf = new_buffer(obuf, &obufend, &file);
  267.       *obuf++ = '*';          /* Terminate the comment */
  268.       *obuf++ = '/';
  269.     }
  270.     continue;
  271.  
  272.       case '/':                /* Start of C++ comment? */
  273.     if (p == '/') {
  274.       if (keepcomments) {
  275.         newdelim = '\n';
  276.         new_is_string = TRUE;
  277.         break;
  278.       }                  /* Eat comment */
  279.       while ((c = get()) != EOF_CHAR && c != '\n');
  280.       if (obuf >= obufend)      /* End of buffer, get a new one */
  281.         obuf = new_buffer(obuf, &obufend, &file);
  282.       *obuf++ = c;          /* Preserve newlines */
  283.     }
  284.     continue;
  285.  
  286.       default:
  287.       continue;    /* Loop to next character, unless break above */
  288.       }    /* end switch */
  289.       if (is_top_level && newdelim == delim) {
  290.     is_top_level = FALSE;
  291.     continue;        /* at top_level, with left side of delimiter */
  292.       }
  293.       file->bptr = obuf;
  294.       file = copy_body(file, newdelim, new_is_string, FALSE, expand);
  295.       if (file == NULL)
  296.     return(NULL);
  297.       obuf = file->bptr;        /* -> output buffer    */
  298.       obufend = file->buffer + (NBUFF - 1); /* Note its end        */
  299.       new_is_string = FALSE;
  300.       c = EOS; /* don't know what last character is anymore */
  301.     }  /* if !is_string */
  302.   } /* end while */
  303.   fprintf(stderr, "Searching for '%c'\n", delim); /* DEBUG */
  304.   infile = getfile(1, current_file);      /* Hack up infile */
  305.   infile->fp = stdin;              /* to print correct file */
  306.   line = current_line;              /* and line number */
  307.   cfatal("End of file during %s macro expansion.", file->filename);
  308.   return(NULL);
  309. } /* copy_body */
  310.  
  311. #if !(HOST == SYS_OS2 || HOST == SYS_VMS || HOST == SYS_MVS)
  312. /*
  313.  *  support for fork and pipe on unix machines only
  314.  */
  315.  
  316. /*
  317.  * Copy two files in parallel: from in1 to out2 and in2 to out2 
  318.  * Returns when both copies are complete, closing all files.
  319.  * in1 and out2 will not block (i.e. they're files)
  320.  * out1 and in2 may be pipes and can block for long periods
  321.  */
  322. static void
  323. doublecopy (in1, out1, in2, out2)
  324.  
  325.   FILEINFO    *in1, *out2;  
  326.   int           out1, in2;
  327. {
  328.   fd_set readfds;
  329.   fd_set writefds;
  330.   fd_set errorfds;
  331.   int n, width;
  332.   int is_first = TRUE;
  333.   char* outptr = in1->buffer;
  334.  
  335.   width = 1 + ((in2 > out1) ? in2 : out1); /* width = max(in2, out1); */
  336.  
  337.   do {
  338.     FD_ZERO(&readfds);
  339.     FD_ZERO(&writefds);
  340.     FD_ZERO(&errorfds);
  341.     if (in2  >= 0) FD_SET(in2, &readfds);
  342.     if (out1 >= 0) FD_SET(out1, &writefds);
  343.  
  344.     if (select(width, &readfds, &writefds, &errorfds, NULL) <= 0)
  345.       perror("Select Error");
  346.  
  347.     if (out1>=0 && FD_ISSET(out1, &errorfds))
  348.       perror("Select output Error");
  349.  
  350.     if (in2>=0 && FD_ISSET(in2, &errorfds))
  351.       perror("Select input Error");
  352.  
  353.     if (!(out1>=0 && FD_ISSET(out1, &writefds)) &&
  354.     !(in2>=0 && FD_ISSET(in2, &readfds))) {
  355.       perror("Select when nothing happened");
  356.     }
  357.  
  358.     if (out1>=0 && FD_ISSET(out1, &writefds)) {
  359.       if (in1 == NULL) {
  360.     close(out1);
  361.     out1 = -1;
  362.       } else {
  363.     int nbytes = in1->bptr - outptr;
  364.     int wbytes = write(out1, outptr, nbytes);
  365.     if (wbytes < 0)
  366.       perror("Error writing to pipe");
  367.     outptr += wbytes;
  368.     if (nbytes == wbytes) {
  369.       in1 = in1->parent;
  370.       if (in1 != NULL)
  371.         outptr = in1->buffer;
  372.     }
  373.       }
  374.     }
  375.  
  376.     if (in2>=0 && FD_ISSET(in2, &readfds)) {
  377.       if (is_first)
  378.     is_first = FALSE;
  379.       else {                /* Chain in a new buffer */
  380.     FILEINFO* new = get_temp_file(NBUFF, out2->filename);
  381.     new->parent = out2->parent;    /* When new ends read from infile */
  382.     out2->parent = new;            /* When out2 dries up, read from new */
  383.     out2 = new;
  384.       }
  385.       n = read(in2, out2->buffer, NBUFF);
  386.       if (n <= 0) {
  387.     if(n<0)
  388.       perror("Error reading from pipe");
  389.     close(in2);
  390.     in2 = -1;
  391.       } else {
  392.     char* p = out2->buffer + n;
  393.     *p = EOS;    
  394.       }
  395.     }
  396.   } while (in2>=0 || out1>=0);
  397. } /* end doublecopy */
  398.  
  399. /*
  400.  * Fork an external macro expander
  401.  */
  402. static void
  403. fork_macro (args, ifile, ofile)
  404.      struct macroargs* args;
  405.      FILEINFO *ifile, *ofile;
  406. {     
  407.   int inchannel, outchannel;
  408.   int forkin, forkout;
  409.   int pid, status;
  410.   {                    /* Create the pipes */
  411.     int sv[2];
  412.     pipe (sv);
  413.     forkin = sv[0];
  414.     outchannel = sv[1];
  415.     pipe (sv);
  416.     inchannel = sv[0];
  417.     forkout = sv[1];
  418.   }
  419.                     /* Fork the macro process */
  420.   if ((pid = fork ()) == 0) {
  421.     /* child process.  Move pipes to stdin and stdout then exec */
  422.     close(0); dup2(forkin, 0);
  423.     close(1); dup2(forkout, 1);
  424.     close(forkin);
  425.     close(forkout);
  426.     close(inchannel);  /* Close files used only by the parent */
  427.     close(outchannel);
  428.     execv(args->program, args->args);
  429.     /* execv never returns */
  430.   }
  431.   close(forkin);  /* Close files used only by the child */
  432.   close(forkout);
  433.   if (pid < 0) 
  434.     cfatal("Can't fork %s macro.", args->program);
  435.   /* Make output to the pipe non-blocking to avoid deadlocks */
  436.   fcntl(outchannel, F_SETFL, FNDELAY | fcntl(outchannel, F_GETFL, 0));
  437.   doublecopy (ifile, outchannel, inchannel, ofile);
  438.   wait(&status);
  439.   if(status != 0)
  440.     cerror("Error during %s macro expansion", args->program);
  441. } /* end fork_macro */
  442.  
  443. #else
  444. /* 
  445.  * execute macro using temp files to redirect stdin and stdout
  446.  * temp file implementation used for DOS, VMS and MVS ports
  447.  * instead of fork/pipe implementation
  448.  */
  449. void run_macro (macname, args, in, out)
  450.     char* macname;
  451.     char* args[];
  452.     char *in, *out;
  453. {
  454.     int status;
  455.     int ifd, ofd;
  456. #if HOST != SYS_OS2 && HOST != SYS_MVS
  457.     /* 
  458.      * no fork function on OS2 or MVS
  459.      */
  460.     int pid;
  461.     if ((pid=fork()) == 0) {
  462.       /* child process */
  463.       ifd = open(in, O_RDONLY);
  464.       if (ifd < 0) {
  465.     perror("cpp exec macro error");
  466.     cerror("Cannot open external macro temp file \"%s\"", in);
  467.     return;
  468.       }
  469.       ofd = open(out, O_WRONLY | O_CREAT | O_TRUNC, 0644);
  470.       if (ofd < 0) {
  471.     perror("cpp exec macro error");
  472.     cerror("Cannot open external macro temp file \"%s\"", out);
  473.     return;
  474.       }
  475.       if (dup2(ifd, 0) < 0) {
  476.     perror("cpp exec macro error");
  477.     cerror("Cannot dup external macro temp file \"%s\"", in);
  478.     return;
  479.       }
  480.       if (dup2(ofd, 1) < 0) {
  481.     perror("cpp exec macro error");
  482.     cerror("Cannot dup external macro temp file \"%s\"", out);
  483.     return;
  484.       }
  485.       execvp(macname, args);
  486.       perror("cpp exec macro error");
  487.       cerror(stderr, "cpp: Cannot execute %s\n", macname);
  488.       close(ifd);
  489.       close(ofd);
  490.     }
  491.     if (pid < 0)
  492.       cfatal("Cannot execute %s\n", macname);
  493.     wait(&status);
  494. #else
  495.     /* for OS/2 and MVS
  496.      * use system function to execute macro with command interpreter
  497.      */
  498.     char arglist[256];
  499.     char subarg[256];
  500.     char command[512];
  501.     char* c;
  502.     /* build arglist of macro command */
  503.     char** argp = &args[1];          /* skip macro name */
  504.     if (*argp != NULL) {
  505.       sprintf(arglist,"%s", *argp);
  506.       for (++argp; *argp !=NULL; argp++) {
  507.     strcpy(subarg,arglist);
  508.     sprintf(arglist,"%s %s",subarg, *argp);
  509.       }
  510.     } else strcpy(arglist,"");
  511.     for (c = macname; *c != '\n'; c++)
  512.       if (*c == '/') *c = '\\';
  513.     /* build complete command redirecting stdin and stdout to temp files */
  514.     sprintf(command,"%s %s < %s > %s",macname,arglist,in,out);
  515.     /* execute command */
  516.     status = system(command);
  517. #endif
  518.     if(status != 0)
  519.       cerror("Error during %s macro expansion", macname);
  520. } /* end of run_macro */
  521.  
  522. #if HOST == SYS_OS2 || HOST == SYS_MVS
  523. static char* TMPDIR = "E:\\";
  524. #else
  525. static char* TMPDIR = "/tmp/";
  526. #endif
  527.  
  528. /* exec macro using temp files to redirect stdin and stdout */
  529. void exec_macro (args, ifile, ofile)
  530.      struct macroargs* args;
  531.      FILEINFO *ifile, *ofile;
  532. {     
  533.   char tmpin[256];
  534.   char tmpout[256];
  535.   FILEINFO *f;
  536.   int n, ifds,ofds;
  537.   char* p;
  538.  
  539.   /* make temp file names using process id */
  540.   sprintf(tmpin, "%s%s%d", TMPDIR, "in", getpid() % 9999);
  541.   sprintf(tmpout, "%s%s%d", TMPDIR, "out", getpid() % 9999);
  542.  
  543.   /* copy ifile to input temp file and close it */
  544.   ifds = open(tmpin, O_WRONLY | O_CREAT | O_TRUNC, 0644);
  545.   if (ifds < 0) {
  546.     perror("cpp exec macro error");
  547.     cerror("Cannot open external macro temp file \"%s\"", tmpin);
  548.     return;
  549.   }
  550.   f = ifile;
  551.   for (;;) {
  552.     n = write(ifds, f->buffer, f->bptr - f->buffer);
  553.     if (n < 0) {
  554.       perror("cpp macro error");
  555.       cerror("Cannot write to external macro temp file \"%s\"", tmpin);
  556.       close(ifds);
  557.       return;
  558.     }
  559.     if ((f = f->parent) == NULL) break;
  560.   }
  561.   close(ifds);
  562.  
  563.   /*  fork and exec external macro */
  564.   run_macro(args->program, args->args, tmpin, tmpout);
  565.  
  566.   /* copy output temp file to ofile and close it */
  567.   ofds = open(tmpout, O_RDONLY);
  568.   if (ofds < 0) return;
  569.   n = read(ofds, ofile->buffer, NBUFF);
  570.   for (;;) {
  571.     FILEINFO* new;
  572.     if (n <= 0) break;
  573.     p = ofile->buffer + n;
  574.     *p = EOS;
  575.     new = get_temp_file(NBUFF, ofile->filename);
  576.     new->parent = ofile->parent;
  577.     ofile->parent = new;
  578.     ofile = new;
  579.     n = read(ofds, ofile->bptr, NBUFF);
  580.   }
  581.   close(ofds);
  582.  
  583.   /* remove temp files */
  584.   unlink(tmpin);
  585.   unlink(tmpout);
  586. }
  587.  
  588. #endif  /* for DOS or VMS or MVS */
  589.  
  590. /*
  591.  * Call an internal macro expander
  592.  */
  593. static void
  594. call_expander (args, ifile, ofile)
  595.      struct macroargs* args;
  596.      FILEINFO *ifile, *ofile;
  597. {     
  598.   int nargs = 0;
  599.   char** arg = args->args;
  600.   while(*arg++ != NULL) nargs++;    /* Count args */
  601.   *ifile->bptr = EOS;
  602.   ifile->bptr = ifile->buffer;
  603.   MacInFile = ifile;            /* Set global I/O buffers */
  604.   MacOutFile = ofile;
  605.   MacOutEnd = ofile->buffer + (NBUFF - 1);
  606.   if (((*args->expander)(nargs, args->args)) != 0)
  607.     cerror("Error during internal %s macro expansion", args->program);
  608.   *MacOutFile->bptr = EOS;
  609.   MacOutFile->bptr = MacOutFile->buffer;
  610. }
  611. /*
  612.  * Expand an external macro.
  613.  *   1. Grab the macro name and everything until the next semicolon
  614.  *      (includling all matching {} [] () <> "" '' and comments found along
  615.  *      the way), and put it in a macro buffer.  Commands found along
  616.  *      the way are processed.
  617.  *   2. Pipe this into the macro, and put the result in another macro buffer.
  618.  *   3. Process the macro expansion.
  619.  */
  620. void
  621. expand_external(dp)
  622.   char* dp;
  623. {
  624.   FILEINFO    *ifile, *ofile;    /* The first output file buffer */
  625.   struct macroargs* args = (struct macroargs*) dp; /* macro arguments */
  626.   char* name = args->name;        /* Macro name */
  627.   extern int macroid();            /* Get a macro-expanded character */
  628.  
  629.   if(!args->recursive) {
  630.     FILEINFO *f;            /* If recursion where it isn't allowed */
  631.     for (f = infile; (f->parent != NULL); f = f->parent) {
  632.       if(strcmp(f->filename, name) == 0) {
  633.     fputs(name, stdout);    /* Skip expansion */
  634.     return;}}}
  635.   /*
  636.    * Ensure the start is correct
  637.    */
  638.   strcpy(work, name);
  639.   workp = work + strlen(name);
  640.   { char c;            /* current character */
  641.     char d = args->conditional;
  642.     if(d != EOS) {        /* check for conditional character */
  643.       instring = TRUE;
  644.       while(isspace(c = get())) *workp++ = c;
  645.       *workp = EOS;
  646.       instring = FALSE;
  647.       unget();
  648.       if (c != d) {        /* When no conditional character, exit */
  649. #ifdef paranoia
  650.     cwarn("defmacro \"%s\" needs arguments", name);
  651. #endif
  652.                 /* Place macro name back in input stream */
  653.                 /* being careful to avoid recursion */
  654.     /* fputs(work, stdout); this isn't good enough */
  655.     ofile = get_temp_file(strlen(work)+1, name);
  656.     ofile->parent = infile;
  657.     ofile->buffer[0] = DEF_MAGIC;
  658.     strcpy(ofile->buffer+1, work);
  659.     infile = ofile;
  660.     return;
  661.       }
  662.     }
  663.   }
  664.   current_line = line;
  665.   strcpy(current_file,
  666.      (infile->progname != NULL) ? infile->progname : infile->filename);
  667.   /*
  668.    * Copy everything to the next ;
  669.    */
  670.   ifile = get_temp_file(NBUFF, name);
  671.   ofile = get_temp_file(NBUFF, name);
  672.   strcpy(ifile->buffer, work);    /* Send name to macro expander */
  673.   ifile->bptr = ifile->buffer + strlen(work);
  674.   instring = TRUE;        /* Ensure comments get copied too */
  675.   if (copy_body(ifile, args->delimiter, FALSE, TRUE, args->expanding) == NULL) {
  676.     instring = FALSE;
  677.     return;
  678.   }
  679.   instring = FALSE;
  680.   infile->line = line;
  681.   /*
  682.    * Expand the macro
  683.    */
  684.   ofile->parent = infile;
  685.   if (args->expander == NULL) {
  686. #if !(HOST == SYS_OS2 || HOST == SYS_VMS || HOST == SYS_MVS)
  687.     fork_macro(args, ifile, ofile);
  688. #else
  689.     exec_macro(args, ifile, ofile);
  690. #endif
  691.   }
  692.   else
  693.     call_expander(args, ifile, ofile);
  694.   infile = ofile;
  695. }
  696.  
  697. /*
  698.  * scanthing(delim)
  699.  *   Copy from input to work, stopping at delim
  700.  *   but including everything with matching {} [] ()
  701.  *   <> "" '' and comments found along the way.
  702.  */
  703. static int
  704. scanthing(delim, is_string, is_top_level)
  705.   char delim;                     /* Current delimiter */
  706.   int is_string, is_top_level;            /* flags */
  707. {
  708.   char c;                     /* Current character */
  709.   char newdelim;            /* New delimiter to look for */
  710.   int new_is_string = FALSE;        /* New is_string flag */
  711.  
  712.   if (is_top_level) {            /* Skip leading whitespace */
  713.     workp = work;
  714.     c = skipws();
  715.     unget();
  716.   }
  717.   while ((c = get()) != EOF_CHAR) {
  718.     save(c);
  719.     if (delim == c &&            /* Quit when delimeter found */
  720.     delim != ' ') {
  721.       *workp = EOS;
  722.       return FALSE;
  723.     }
  724.     if (!is_string) {
  725.       switch (c) {        /* Look for new delimeters when not is_string */
  726.       case ' ':
  727.       case ',':
  728.       case '\t':
  729.       case '\n':
  730.     if (delim == ' ') {
  731.       unget();
  732.       workp -= 1;
  733.       *workp = EOS;
  734.       return FALSE;
  735.     } else continue;
  736.       case '{':  newdelim = '}'; break;
  737.       case '[':  newdelim = ']'; break;
  738.       case '(':  newdelim = ')'; break;
  739.       case '\'':  newdelim = '\''; new_is_string = TRUE; break;
  740.       case '\"':  newdelim = '\"'; new_is_string = TRUE; break;
  741.       default: 
  742.     continue;        /* Loop to next character, unless break above */
  743.       }    /* end switch */
  744.       if (is_top_level && newdelim == delim) {
  745.     is_top_level = FALSE;
  746.     continue;        /* at top_level, with left side of delimiter */
  747.       }
  748.       scanthing(newdelim, new_is_string, FALSE);
  749.       new_is_string = FALSE;
  750.     }  /* if !is_string */
  751.   } /* end while */
  752.   return (c == EOF_CHAR);
  753. } 
  754. /*
  755.  * create a new defmacro (internal function)
  756.  */
  757. void
  758. new_defmacro(name, expanding, recursive, delimiter, conditional, 
  759.          expander, program, args)
  760.   char* name;
  761.   char  expanding;        /* Non-zero when args are macro expanded */
  762.   char  recursive;        /* Non-zero when recursive */
  763.   char  delimiter;        /* Delimiter */
  764.   char  conditional;        /* Expand only if this char found after name */
  765.   internal_expander expander;    /* Macro expander or NULL if file */
  766.   char *program;        /* macro program pathname */
  767.   char** args;            /* arg list (vector of strings) */
  768. {
  769.   struct macroargs* new;
  770.   int nargs = 1;
  771.   char** argp;
  772.  
  773.   if (args == NULL) {              /* Setup default args */
  774.     args = (char**) getmem(sizeof(char*)*2);
  775.     args[0] = program;
  776.     args[1] = NULL;
  777.   }
  778.   for(argp = args; *argp++!=NULL; nargs++);    /* Count arguments */
  779.  
  780.   new = (struct macroargs*) getmem(sizeof(struct macroargs) +
  781.                    (nargs*sizeof(char*)));
  782.   new->name = name;
  783.   new->expanding = expanding;
  784.   new->recursive = recursive;
  785.   new->delimiter = delimiter;
  786.   new->conditional = conditional;
  787.   new->expander = expander;
  788.   new->program = program;
  789.   while(nargs-- > 0)
  790.     new->args[nargs] = args[nargs];
  791.   define_builtin(name, expand_external, (char*) new);
  792. }
  793.  
  794. /*
  795.  * Define an external macro handler
  796.  *
  797.  *     Called when #pragma defmacro
  798.  *     is found in the input.
  799.  * The complete form is:
  800.  * #pragma defmacro name <file> options
  801.  * #pragma defmacro name "file" options
  802.  * #pragma defmacro name program options
  803.  *
  804.  * where "options" is zero or more of the following:
  805.  *  recursive    - when present, the macro is recursively expanded
  806.  *  delimiter=?  - the default delimiter of ; is replaced with ?
  807.  *  condition=?  - Expand only if this char found after name
  808.  *  other        - other options are passed as arguments to the
  809.  *                 macro expander
  810.  */
  811. void
  812. define_external()
  813. {
  814.   char c;
  815.   char delim;
  816.   char* name;
  817.   char* program;
  818.   int nargs = 1;
  819.   int maxargs = 32;
  820.   char* args[32];
  821.   int recursive = 0;
  822.   int expanding = 0;
  823.   int delimiter = ';';
  824.   int conditional = EOS;
  825.   internal_expander expander = NULL;
  826.  
  827.   c = skipws();
  828.   scanid(c);
  829.   name = savestring(tokenbuf);
  830.   program = name;
  831.         /* Parse_include returns EOS for internal macros (no " or <) */
  832.   delim = parse_include();          /* Get program to work */
  833.   strcpy(tokenbuf, work); /* Keep copy because findinclude mangles it */
  834. #if HOST == SYS_OS2
  835.   strcat(work,".exe");
  836. #endif
  837.   if (delim == EOS || findinclude(work, (delim == '"'), X_OK) == FALSE) {
  838.     struct expander_pair* p = internal_macros; /* Macro file not found */
  839.     strcpy(work, tokenbuf);                    /* restore progam name */
  840.     for (; p->name != NULL; p++)           /* Search for internal macro */
  841.       if (strcmp(p->name, work) == 0) {
  842.     expander = p->function;
  843.     goto found_internal;
  844.       }    
  845.     cerror("Cannot open macro file \"%s\"", work);
  846.     goto macerr;
  847.   }
  848. /*
  849. #if HOST == SYS_VMS || HOST == SYS_MVS
  850.   else {
  851.     cerror("External macros not supported for \"%s\"", work);
  852.     goto macerr;
  853.   }
  854. #endif
  855. */
  856. found_internal:
  857.   program = args[0] = savestring(work);
  858.  
  859.   c = skipws();
  860.   while (c != '\n' && c != EOF_CHAR) {
  861.     while (c == ',') {
  862.       args[nargs++] = ",";
  863.       c = skipws();
  864.     }
  865.     unget();
  866.     if (scanthing(' ', FALSE, TRUE))
  867.       cfatal("End of file during #pragma defmacro %s processing.", name);
  868.     if(strcmp(work, "recursive") == 0) {
  869.       recursive = 1;
  870.       c = skipws();
  871.       continue;
  872.     }
  873.     if(strcmp(work, "expanding") == 0) {
  874.       expanding = 1;
  875.       continue;
  876.     } 
  877.     {
  878.       int* option = NULL;
  879.       if(strncmp(work, "delimiter", 9) == 0) option = &delimiter;
  880.       if(strncmp(work, "condition", 9) == 0) option = &conditional;
  881.       if(option != NULL) {
  882.     if (work[9] != '=' && (c = skipws()) != '=') {
  883.       cerror("In #pragma defmacro, Missing = after %s", work);
  884.       goto macerr;
  885.     }
  886.     if(strlen(work) == 11)
  887.       *option = work[10];
  888.     else 
  889.       *option = skipws();
  890.     if(*option != '\n') c = skipws();
  891.     continue;
  892.       }
  893.     }                /* must be a program option */
  894.     if (nargs >= maxargs) {
  895.       cerror("In #pragma defmacro %s, too many arguments.", name);
  896.       goto macerr;
  897.     }
  898.     args[nargs] = savestring(work);
  899.     nargs++;
  900.     c = skipws();
  901.   } /* end while not newline */
  902.   unget();            /* Force nl after includee    */
  903.   args[nargs] = NULL;
  904.   new_defmacro(name, expanding, recursive, delimiter, conditional, 
  905.            expander, program, args);
  906.   return;
  907.  
  908.  macerr:
  909.   skipnl();            /* Skip to end of line */
  910.   unget();            /* Force nl */
  911.   return;
  912. }
  913.  
  914. /*-----------------------------------------------------------------------------
  915.  * Process DEFPACKAGE command.
  916.  * format is: defpackage NAME <path> options
  917.  * where options are optional and seperated by comma's.
  918.  *
  919.  * This really should be an internal defmacro, but
  920.  * it was so much easier to handle it here...
  921.  */
  922. static char* defpackage_options[] = {
  923.   "length", "case",
  924.   "start", "increment", "template", "max", "use_first", "nospace", NULL};
  925.  
  926. void
  927. define_package(dp)
  928.   char* dp;
  929. {
  930.   extern void package_define();
  931.   char c;
  932.   char delim;
  933.   char* pkgname;
  934.   char* pkgfile;
  935.   char* options[8];
  936.   long loptions[6];
  937.   int np;
  938.   char errmsg[100];
  939.  
  940.   options[0]=""; options[1]=""; options[2]=""; options[3]="";
  941.   options[4]=""; options[5]=""; options[6]=""; options[7]="";
  942.   c = skipws();
  943.   scanid(c);
  944.   pkgname = savestring(tokenbuf);
  945.   if((delim = parse_include()) == EOS) {
  946.     cerror("DEFPACKAGE syntax error", NULLST);
  947.     goto macerr;
  948.   }
  949.   if (findinclude(work, (delim == '"'), R_OK) == FALSE) {
  950.     cerror("Cannot open package header file \"%s\"", work);
  951.     goto macerr;
  952.   }
  953.   pkgfile = savestring(work);
  954.                       /* Get options */
  955.   while ((c=skipws()) != '\n' && c != EOF_CHAR) {
  956.     char** p;
  957.     if (c == ',')              /* Skip over commas */
  958.       if ((c=skipws()) == '\n' || c == EOF_CHAR)
  959.     break;
  960.     scanid(c);
  961.     np = 0;
  962.     p = defpackage_options;
  963.     for (; *p != NULL; p++, np++) 
  964.       if(strcmp(tokenbuf, *p) == 0) break;
  965.     if (*p == NULL) {
  966.       sprintf(errmsg, "In DEFPACKAGE %s, unknown option \"%s\"",
  967.           pkgname, tokenbuf);
  968.       cerror(errmsg, NULLST);
  969.       goto macerr;
  970.     } else if ((c = skipws()) != '=') {
  971.       sprintf(errmsg, "In DEFPACKAGE %s, Missing = after %s option",
  972.           pkgname, tokenbuf);
  973.       cerror(errmsg, NULLST);
  974.       goto macerr;
  975.     } else {
  976.       c = skipws();
  977.       scanid(c);
  978.       options[np] = savestring(tokenbuf);
  979.     }
  980.   }
  981.   unget();  /* Force nl after includee */
  982.                       /* Convert numeric options */
  983.   for(np=2; np<8; np++) {
  984.     char* endp[1];
  985.     long val = strtol(options[np], endp, 0);
  986.     if(**endp != EOS) {
  987.       sprintf(errmsg, "In DEFPACKAGE %s, Illegal value %s for %s option",
  988.           pkgname, options[np], defpackage_options[np]);
  989.       cwarn(errmsg, NULLST);
  990.     }
  991.     loptions[np-2] = val;
  992.   }
  993.   package_define(pkgname, pkgfile, 
  994.          options[0], options[1], loptions[0], loptions[1],
  995.          loptions[2], loptions[3], loptions[4], loptions[5]);
  996.   return;
  997.  
  998.  macerr:
  999.   skipnl();            /* Skip to end of line */
  1000.   unget();            /* Force nl */
  1001.   return;
  1002. }
  1003.